import axios from 'axios'

/**
 * API请求类，封装所有的接口请求方法
 */
class ApiService {
  constructor() {
    // 创建axios实例
    this.axiosInstance = axios.create({
      baseURL: import.meta.env.VITE_API_BASE_URL || '/api',
      timeout: 10000, // 请求超时时间
      headers: {
        'Content-Type': 'application/json'
      }
    })
    
    // 开发环境下打印baseURL信息
    if (import.meta.env.DEV) {
      console.log('API Base URL:', this.axiosInstance.defaults.baseURL)
    }

    // 添加请求拦截器
    this.axiosInstance.interceptors.request.use(
      (config) => {
        // 在发送请求之前做些什么，比如添加token
        const token = localStorage.getItem('token')
        const loginState = localStorage.getItem('loginState')
        
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }
        
        // 开发环境下打印请求信息
        if (import.meta.env.DEV) {
          console.log('API请求:', {
            url: config.url,
            method: config.method,
            hasToken: !!token,
            loginState: loginState ? '已登录' : '未登录'
          })
        }
        
        return config
      },
      (error) => {
        // 处理请求错误
        console.error('请求拦截器错误:', error)
        return Promise.reject(error)
      }
    )

    // 添加响应拦截器
    this.axiosInstance.interceptors.response.use(
      (response) => {
        // 2xx范围内的状态码都会触发这个函数
        // 统一返回对象格式
        const responseData = response.data || {};
        
        // 如果后端已经返回了标准格式，则直接使用
        if (responseData.code !== undefined) {
          return responseData;
        }
        
        // 否则包装成统一格式
        return {
          code: 200,
          message: 'success',
          data: responseData,
          ...responseData,
          requestId: response.headers['x-request-id'] || null
        };
      },
      (error) => {
        // 超出2xx范围的状态码都会触发这个函数
        const errorInfo = this.handleError(error);
        console.error('API请求错误:', errorInfo);
        
        // 统一错误返回格式
        const errorResponse = {
          code: errorInfo.code || 500,
          message: errorInfo.message,
          data: null
        };
        
        return Promise.reject(errorResponse);
      }
    )
  }

  /**
   * 统一错误处理
   * @param {Object} error - 错误对象
   * @returns {Object} - 格式化的错误信息对象
   */
  handleError(error) {
    if (error.response) {
      // 请求已发出，但服务器响应的状态码不在 2xx 范围内
      const { status, data } = error.response
      console.log('错误响应:', error.response)
      // 提取错误信息
      const errorMessage = data.error || data.message ||  data || `请求失败，状态码: ${status}`;
      
      switch (status) {
        case 401:
          // 未授权，清除token并跳转到登录页
          localStorage.removeItem('token')
          localStorage.removeItem('user')
          localStorage.removeItem('loginState')
          if (window.location.pathname !== '/') {
            window.location.href = '/'
          }
          return {
            code: 401,
            message: errorMessage || '登录已过期，请重新登录'
          }
        case 403:
          return {
            code: 403,
            message: errorMessage
          }
        case 404:
          return {
            code: 404,
            message: errorMessage
          }
        case 422:
          // 验证错误，通常包含详细的字段错误
          return {
            code: 422,
            message: errorMessage,
            fieldErrors: data.errors || null
          }
        case 500:
          return {
            code: 500,
            message: errorMessage
          }
        default:
          return {
            code: status,
            message: errorMessage
          }
      }
    } else if (error.request) {
      // 请求已发出，但没有收到响应
      return {
        code: 503,
        message: '网络错误，请检查您的网络连接'
      }
    } else {
      // 发送请求时出错
      return {
        code: 400,
        message: `请求配置错误: ${error.message}`
      }
    }
  }

  /**
   * 过滤对象中的空字段
   * @param {Object} obj - 要过滤的对象
   * @returns {Object} - 过滤后的新对象
   */
  filterEmptyFields(obj) {
    if (!obj || typeof obj !== 'object') {
      return obj
    }

    // 如果是FormData对象，直接返回，不做处理
    if (obj instanceof FormData) {
      return obj
    }

    const filteredObj = {}
    
    for (const key in obj) {
      if (Object.prototype.hasOwnProperty.call(obj, key)) {
        const value = obj[key]
        
        // 过滤掉undefined、null、空字符串、空数组、空对象
        if (
          value !== undefined && 
          value !== null && 
          !(typeof value === 'string' && value.trim() === '') &&
          !(Array.isArray(value) && value.length === 0) &&
          !(typeof value === 'object' && Object.keys(value).length === 0)
        ) {
          filteredObj[key] = value
        }
      }
    }
    
    return filteredObj
  }

  /**
   * GET请求方法
   * @param {string} url - 请求URL
   * @param {Object} params - 请求参数
   * @param {Object} config - 额外配置
   * @returns {Promise} - 返回Promise对象
   */
  async get(url, params = {}, config = {}) {
    try {
      // 过滤params中的空字段
      const filteredParams = this.filterEmptyFields(params)
      return await this.axiosInstance.get(url, { params: filteredParams, ...config })
    } catch (error) {
      throw error
    }
  }

  /**
   * POST请求方法
   * @param {string} url - 请求URL
   * @param {Object} data - 请求数据
   * @param {Object} config - 额外配置
   * @returns {Promise} - 返回Promise对象
   */
  async post(url, data = {}, config = {}) {
    try {
      // 过滤data中的空字段
      const filteredData = this.filterEmptyFields(data)
      return await this.axiosInstance.post(url, filteredData, config)
    } catch (error) {
      throw error
    }
  }

  /**
   * PUT请求方法
   * @param {string} url - 请求URL
   * @param {Object} data - 请求数据
   * @param {Object} config - 额外配置
   * @returns {Promise} - 返回Promise对象
   */
  async put(url, data = {}, config = {}) {
    try {
      // 过滤data中的空字段
      const filteredData = this.filterEmptyFields(data)
      return await this.axiosInstance.put(url, filteredData, config)
    } catch (error) {
      throw error
    }
  }

  /**
   * DELETE请求方法
   * @param {string} url - 请求URL
   * @param {Object} config - 额外配置
   * @returns {Promise} - 返回Promise对象
   */
  async delete(url, config = {}) {
    try {
      return await this.axiosInstance.delete(url, config)
    } catch (error) {
      throw error
    }
  }

  /**
   * PATCH请求方法
   * @param {string} url - 请求URL
   * @param {Object} data - 请求数据
   * @param {Object} config - 额外配置
   * @returns {Promise} - 返回Promise对象
   */
  async patch(url, data = {}, config = {}) {
    try {
      // 过滤data中的空字段
      const filteredData = this.filterEmptyFields(data)
      return await this.axiosInstance.patch(url, filteredData, config)
    } catch (error) {
      throw error
    }
  }

  /**
   * 文件上传方法
   * @param {string} url - 请求URL
   * @param {FormData} formData - 包含文件的FormData对象
   * @param {Object} config - 额外配置，如上传进度回调
   * @returns {Promise} - 返回Promise对象
   */
  async upload(url, formData, config = {}) {
    try {
      // 设置上传头信息
      const uploadConfig = {
        ...config,
        headers: {
          ...config.headers,
          'Content-Type': 'multipart/form-data'
        }
      }
      
      return await this.axiosInstance.post(url, formData, uploadConfig)
    } catch (error) {
      console.error('文件上传失败:', error)
      throw error
    }
  }

  // ===== 用户相关API =====
  
  /**
   * 检查用户是否已登录
   * @returns {boolean} - 返回用户是否已登录
   */
  isLoggedIn() {
    const token = localStorage.getItem('token')
    const loginState = localStorage.getItem('loginState')
    
    // 简单验证：检查token是否存在且loginState表明已登录
    if (token && loginState) {
      try {
        const state = JSON.parse(loginState)
        return state.isLoggedIn === true
      } catch (error) {
        console.error('解析登录状态失败:', error)
        return false
      }
    }
    return false
  }
  
  /**
   * 获取当前登录用户信息
   * @returns {Object|null} - 返回用户信息对象或null
   */
  getCurrentUser() {
    const userInfo = localStorage.getItem('user')
    if (userInfo) {
      try {
        return JSON.parse(userInfo)
      } catch (error) {
        console.error('解析用户信息失败:', error)
        return null
      }
    }
    return null
  }
  
  /**
   * 获取当前登录状态详情
   * @returns {Object} - 返回登录状态详情对象
   */
  getLoginStatus() {
    const isLoggedIn = this.isLoggedIn()
    const userInfo = this.getCurrentUser()
    const token = localStorage.getItem('token')
    const loginState = localStorage.getItem('loginState')
    
    let stateDetails = {}
    if (loginState) {
      try {
        stateDetails = JSON.parse(loginState)
      } catch (error) {
        console.error('解析登录状态详情失败:', error)
      }
    }
    
    return {
      isLoggedIn,
      userInfo,
      hasToken: !!token,
      tokenType: stateDetails.tokenType || 'unknown',
      loginTime: stateDetails.loginTime || null
    }
  }

  /**
   * 获取用户信息
   * @returns {Promise} - 返回Promise对象
   * 缓存策略：localStorage中的用户信息5分钟后过期，缓存存在时不请求接口，反之请求
   */
  async getUserInfo() {
    // 缓存过期时间（毫秒）：5分钟 = 5 * 60 * 1000 = 300000
    const CACHE_EXPIRY_TIME = 300000;
    
    try {
      // 检查localStorage中是否有缓存的用户信息和缓存时间
      const cachedUserInfo = localStorage.getItem('user');
      const cachedTime = localStorage.getItem('userCacheTime');
      
      // 如果有缓存且未过期，直接返回缓存的用户信息
      if (cachedUserInfo && cachedTime) {
        const cacheTime = parseInt(cachedTime);
        const currentTime = new Date().getTime();
        
        if (currentTime - cacheTime < CACHE_EXPIRY_TIME) {
          console.log('=== 使用缓存的用户信息（未过期）===');
          return JSON.parse(cachedUserInfo);
        }
        console.log('=== 缓存已过期，重新请求用户信息 ===');
      }
      
      // 如果没有缓存或缓存已过期，请求接口获取新的用户信息
      console.log('=== 正在调用getUserInfo接口获取用户信息 ===');
      const response = await this.get('/users/me');
      console.log('=== getUserInfo接口调用成功，响应数据:', response);
      
      const responseData = response.code !== undefined ? response.data : response;
      console.log('=== 从响应中提取的用户信息:', response);
    
      // 保存用户信息和缓存时间到localStorage
      localStorage.setItem('user', JSON.stringify(responseData && responseData.data || responseData));
      localStorage.setItem('userCacheTime', new Date().getTime().toString());
      console.log('=== 用户信息已缓存，缓存时间:', new Date().toLocaleTimeString());
      
      return responseData;
    } catch (error) {
      console.error('=== 获取用户信息失败:', error);
      throw error;
    }
  }

  /**
   * 用户登录
   * @param {Object} credentials - 登录凭证
   * @returns {Promise} - 返回Promise对象
   */
  async login(credentials) {
    const { email, password } = credentials;
    try {
      const response = await this.post('/users/login', {username:email, password})
      // 处理统一响应格式
      const responseData = response.code !== undefined ? response.data : response;
      
      // 保存token和用户信息 - 支持多种格式
      const token = responseData.token || responseData.access_token;
      if (token) {
        localStorage.setItem('token', token);
        
        // 登录成功后调用getUserInfo获取完整用户信息
        try {
          // getUserInfo方法已经包含了缓存逻辑，会自动设置user和userCacheTime
          await this.getUserInfo();
          // 这里不需要额外保存user，getUserInfo已经处理了
        } catch (error) {
          console.warn('获取用户信息失败，使用邮箱作为默认用户信息:', error);
          const defaultUserInfo = { email: credentials.email };
          localStorage.setItem('user', JSON.stringify(defaultUserInfo));
          localStorage.setItem('userCacheTime', new Date().getTime().toString());
          console.log('=== 默认用户信息已缓存，缓存时间:', new Date().toLocaleTimeString());
        }
        
        // 保存登录状态信息
        const loginState = {
          isLoggedIn: true,
          tokenType: responseData.token ? 'token' : 'access_token',
          loginTime: new Date().toISOString()
        };
        localStorage.setItem('loginState', JSON.stringify(loginState));
        
        console.log('用户登录成功，状态已保存:', loginState);
      } else {
        console.warn('登录成功但未返回token:', response);
      }
      
      return response;
    } catch (error) {
      console.error('登录API错误:', error);
      throw error;
    }
  }

  /**
   * 用户注册
   * @param {Object} userData - 用户注册数据
   * @returns {Promise} - 返回Promise对象
   */
  async register(userData) {
    return this.post('/users/register', userData)
  }

  /**
   * 用户登出
   * @returns {Promise} - 返回Promise对象
   */
  async logout() {
    try {
      await this.post('/users/logout')
      // 清除本地存储的所有登录相关信息
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      localStorage.removeItem('loginState')
      
      console.log('用户已成功登出，所有登录状态已清除')
    } catch (error) {
      console.error('登出API错误:', error)
      // 即使登出请求失败，也清除本地存储
      localStorage.removeItem('token')
      localStorage.removeItem('user')
      localStorage.removeItem('loginState')
      throw error
    }
  }

  // ===== 音乐相关API =====

  /**
   * 上传音乐文件
   * @param {File} audioFile - 音乐文件对象
   * @param {Object} metadata - 音乐元数据（标题、歌手等）
   * @param {Function} onProgress - 上传进度回调函数
   * @returns {Promise} - 返回Promise对象
   */
  async uploadAudio(audioFile, metadata = {}, onProgress = null) {
    try {
      const formData = new FormData()
      
      // 添加音频文件
      formData.append('file', audioFile)  // 修改为'file'字段，与后端匹配
      
      // 添加元数据
      for (const key in metadata) {
        if (metadata.hasOwnProperty(key)) {
          formData.append(key, metadata[key])
        }
      }
      
      // 配置上传参数
      const config = {}
      
      // 如果提供了进度回调，设置上传进度监控
      if (onProgress && typeof onProgress === 'function') {
        config.onUploadProgress = (progressEvent) => {
          const percentCompleted = Math.round(
            (progressEvent.loaded * 100) / progressEvent.total
          )
          onProgress(percentCompleted)
        }
      }
      
      console.log('=== 开始上传音频文件:', audioFile.name, '元数据:', metadata)
      const response = await this.upload('/songs/upload-file', formData, config)
      console.log('=== 音频文件上传成功:', response)
      
      return response
    } catch (error) {
      console.error('=== 音频文件上传失败:', error)
      throw error
    }
  }

  /**
   * 获取推荐歌曲列表
   * @param {Object} params - 查询参数
   * @returns {Promise} - 返回Promise对象
   */
  async getRecommendedSongs(params = {}) {
    return this.get('/songs/by-category', params)
  }

  /**
   * 获取每日推荐歌曲
   * @param {Object} params - 查询参数
   * @returns {Promise} - 返回Promise对象
   */
  async getDailyRecommendations(params = {}) {
    return this.get('/songs/daily-recommendations', params)
  }

  /**
   * 获取热门歌曲列表
   * @param {Object} params - 查询参数
   * @returns {Promise} - 返回Promise对象
   */
  async getTopSongs(params = {}) {
    return this.get('/songs/top/list', params)
  }

  /**
   * 获取歌曲详情
   * @param {string} songId - 歌曲ID
   * @returns {Promise} - 返回Promise对象
   */
  async getSongDetail(songId) {
    return this.get(`/songs/${songId}`)
  }

  /**
   * 增加歌曲播放量
   * @param {string} songId - 歌曲ID
   * @returns {Promise} - 返回Promise对象
   */
  async incrementPlayCount(url) {
    try {
      return this.post(url)
    } catch (error) {
      console.error('增加播放量失败:', error)
      // 不抛出错误，避免影响播放功能
      return null
    }
  }

  /**
   * 收藏/取消收藏歌曲
   * @param {string} songId - 歌曲ID
   * @param {boolean} isFavorite - 是否收藏（前端状态，后端会根据实际情况处理）
   * @returns {Promise} - 返回Promise对象
   */
  async toggleFavorite(songId, isFavorite) {
    try {
      // 统一使用POST请求，后端会处理具体的收藏/取消收藏逻辑
      return this.post(`/songs/${songId}/collect`)
    } catch (error) {
      console.error(isFavorite ? '收藏歌曲失败:' : '取消收藏失败:', error)
      // 不抛出错误，避免影响用户体验
      return null
    }
  }

  /**
   * 获取歌曲的收藏和点赞状态
   * @param {string} songId - 歌曲ID
   * @returns {Promise} - 返回包含isFavorite和isLiked状态的Promise对象
   */
  async getSongStatus(songId) {
    try {
      const response = await this.get(`/songs/${songId}/status`)
      return response.data
    } catch (error) {
      console.error('获取歌曲状态失败:', error)
      // 出错时返回默认状态
      return {
        isFavorite: false,
        isLiked: false
      }
    }
  }

  /**
   * 点赞/取消点赞歌曲
   * @param {string} songId - 歌曲ID
   * @param {boolean} isLiked - 当前点赞状态（前端状态，后端会根据实际情况处理）
   * @returns {Promise} - 返回Promise对象
   */
  async toggleLike(songId, isLiked) {
    try {
      // 统一使用POST请求，后端会处理具体的点赞/取消点赞逻辑
      return this.post(`/songs/${songId}/like`)
    } catch (error) {
      console.error(isLiked ? '点赞失败:' : '取消点赞失败:', error)
      // 不抛出错误，避免影响用户体验
      return null
    }
  }

  /**
   * 搜索歌曲
   * @param {string} keyword - 搜索关键词
   * @returns {Promise} - 返回Promise对象
   */
  async searchSongs(keyword) {
    return this.get('/songs/search', { keyword })
  }

  // ===== 分类管理相关API =====
  
  /**
   * 获取所有音乐分类
   * @returns {Promise} - 返回分类列表的Promise对象
   */
  async getCategories() {
    try {
      return this.get('/categories')
    } catch (error) {
      console.error('获取分类列表失败:', error)
      // 出错时返回模拟数据
      return {
        code: 200,
        data: [
          { id: 1, name: '流行', description: '流行音乐' },
          { id: 2, name: '摇滚', description: '摇滚音乐' },
          { id: 3, name: '古典', description: '古典音乐' },
          { id: 4, name: '民谣', description: '民谣音乐' },
          { id: 5, name: '爵士', description: '爵士音乐' }
        ]
      }
    }
  }
  
  /**
   * 添加新分类
   * @param {Object} categoryData - 分类数据
   * @returns {Promise} - 返回Promise对象
   */
  async addCategory(categoryData) {
    return this.post('/categories', categoryData)
  }
  
  /**
   * 更新分类
   * @param {string} categoryId - 分类ID
   * @param {Object} categoryData - 更新的分类数据
   * @returns {Promise} - 返回Promise对象
   */
  async updateCategory(categoryId, categoryData) {
    return this.put(`/categories/${categoryId}`, categoryData)
  }
  
  /**
   * 删除分类
   * @param {string} categoryId - 分类ID
   * @returns {Promise} - 返回Promise对象
   */
  async deleteCategory(categoryId) {
    return this.delete(`/categories/${categoryId}`)
  }

  // ===== 用户歌单相关API =====

  /**
   * 获取用户歌单
   * @returns {Promise} - 返回Promise对象
   */
  async getUserPlaylists(params = {}) {
    return this.get('/playlists', params)
  }

  //管理员模块下获取推荐歌单接口
  /**
   * 管理员获取推荐歌单
   * @param {Object} params - 查询参数
   * @returns {Promise} - 返回Promise对象
   */
  async getRecommendedPlaylistsForAdmin(params = {}) {
    return this.get('/admin/recommended-playlists', params)
  }

  /**
   * 获取推荐歌单
   * @returns {Promise} - 返回Promise对象
   */
  async getOfficialPlaylists(params = {}) {
    return this.get('/playlists/official', params)
  }

  /**
   * 创建歌单
   * @param {Object} playlistData - 歌单数据
   * @returns {Promise} - 返回Promise对象
   */
  async createPlaylist(playlistData) {
    return this.post('/playlists', playlistData)
  }

  /**
   * 更新歌单
   * @param {string} playlistId - 歌单ID
   * @param {Object} playlistData - 歌单数据
   * @returns {Promise} - 返回Promise对象
   */
  async updatePlaylist(playlistId, playlistData) {
    console.log(playlistData)
    return this.put(`/playlists/${playlistId}`, playlistData)
  }

  /**
   * 向歌单添加歌曲
   * @param {string} playlistId - 歌单ID
   * @param {string} songId - 歌曲ID
   * @returns {Promise} - 返回Promise对象
   */
  async addSongToPlaylist(playlistId, songId) {
    return this.post(`/playlists/${playlistId}/songs/${songId}`)
  }

  /**
   * 删除歌单
   * @param {string} playlistId - 歌单ID
   * @returns {Promise} - 返回Promise对象
   */
  async deletePlaylist(playlistId) {
    return this.delete(`/playlists/${playlistId}`)
  }

  /**
   * 获取歌单详情（包含歌曲列表）
   * @param {string} playlistId - 歌单ID
   * @returns {Promise} - 返回包含歌曲列表的歌单详情
   */
  async getPlaylistDetail(playlistId) {
    try {
      return this.get(`/playlists/${playlistId}?includeSongs=true`)
    } catch (error) {
      console.error('获取歌单详情失败:', error)
      throw error
    }
  }

  /**
   * 从歌单移除歌曲
   * @param {string} playlistId - 歌单ID
   * @param {string} songId - 歌曲ID
   * @returns {Promise} - 返回Promise对象
   */
  async removeSongFromPlaylist({playlistId, songId}) {
    return this.delete(`/playlists/${playlistId}/songs/${songId}`)
  }
  
  /**
   * 获取用户最近播放的歌曲
   * @param {Object} params - 请求参数
   * @param {number} params.limit - 限制数量（可选）
   * @returns {Promise} - 返回最近播放的歌曲列表
   */
  async getRecentPlays() {
    try {
      return this.get(`/my-music/play-history`)
    } catch (error) {
      console.error('获取最近播放歌曲失败:', error)
      throw error
    }
  }

  /**
   * 获取歌手列表
   * @param {Object} params - 请求参数
   * @param {number} params.page - 页码
   * @param {number} params.pageSize - 每页数量
   * @returns {Promise} - 返回歌手列表
   */
  async getArtists(params = {}) {
    try {
      return this.get(`/singers`, params)
    } catch (error) {
      console.error('获取歌手列表失败:', error)
      // 不抛出错误，让调用方使用备用数据
      return { code: 500, message: '获取歌手列表失败', data: [] }
    }
  }
  
  /**
   * 添加歌手
   * @param {Object} artistData - 歌手数据
   * @returns {Promise} - 返回Promise对象
   */
  async addArtist(artistData) {
    return this.post('/singers', artistData)
  }
  
  /**
   * 更新歌手
   * @param {string} artistId - 歌手ID
   * @param {Object} artistData - 歌手数据
   * @returns {Promise} - 返回Promise对象
   */
  async updateArtist(artistId, artistData) {
    return this.put(`/singers/${artistId}`, artistData)
  }
  
  /**
   * 删除歌手
   * @param {string} artistId - 歌手ID
   * @returns {Promise} - 返回Promise对象
   */
  async deleteArtist(artistId) {
    return this.delete(`/singers/${artistId}`)
  }
  
  /**
   * 获取单个歌手详情
   * @param {string} artistId - 歌手ID
   * @returns {Promise} - 返回歌手详情
   */
  async getArtistDetail(artistId) {
    try {
      return this.get(`/singers/${artistId}`)
    } catch (error) {
      console.error('获取歌手详情失败:', error)
      // 不抛出错误，让调用方使用备用数据
      return null
    }
  }
  
  /**
   * 上传歌手头像
   * @param {string} artistId - 歌手ID
   * @param {File} file - 头像文件
   * @returns {Promise} - 返回包含头像URL的Promise对象
   */
  async uploadSingerAvatar(artistId, file) {
    const formData = new FormData()
    formData.append('file', file)
    
    return this.post(`/singers/${artistId}/avatar`, formData, {
      headers: {
        'Content-Type': 'multipart/form-data'
      }
    })
  }
  
  /**
   * 获取歌手的所有专辑
   * @param {number} singerId - 歌手ID
   * @returns {Promise} - 返回专辑列表
   */
  async getAlbumsBySinger(singerId) {
    try {
      const response = await this.get(`/albums/singer/${singerId}`)
      if (response.code === 200 && Array.isArray(response.data)) {
        return response.data
      } else {
        // 如果返回格式不符合预期，返回空数组
        return []
      }
    } catch (error) {
      console.error('获取歌手专辑列表失败:', error)
      // 出错时返回空数组，让调用方处理
      return []
    }
  }

  /**
   * 获取专辑列表
   * @param {Object} params - 请求参数
   * @param {number} params.page - 页码
   * @param {number} params.limit - 每页数量
   * @returns {Promise} - 返回专辑列表
   */
  async getAlbums(params = {}) {
    try {
      const response = await this.get(`/albums`, params)
      if (response.code === 200) {
        return response
      } else {
        throw new Error('获取专辑列表失败')
      }
    } catch (error) {
      console.error('获取专辑列表失败:', error)
      // 出错时返回模拟数据，让调用方处理
      return { code: 200, data: { data: [], meta: { total: 0 } } }
    }
  }

  /**
   * 添加专辑
   * @param {Object} albumData - 专辑数据
   * @returns {Promise} - 返回Promise对象
   */
  async addAlbum(albumData) {
    try {
      return this.post('/albums', albumData)
    } catch (error) {
      console.error('添加专辑失败:', error)
      throw error
    }
  }

  /**
   * 更新专辑
   * @param {string} albumId - 专辑ID
   * @param {Object} albumData - 专辑数据
   * @returns {Promise} - 返回Promise对象
   */
  async updateAlbum(albumId, albumData) {
    try {
      return this.put(`/albums/${albumId}`, albumData)
    } catch (error) {
      console.error('更新专辑失败:', error)
      throw error
    }
  }

  /**
   * 删除专辑
   * @param {string} albumId - 专辑ID
   * @returns {Promise} - 返回Promise对象
   */
  async deleteAlbum(albumId) {
    try {
      return this.delete(`/albums/${albumId}`)
    } catch (error) {
      console.error('删除专辑失败:', error)
      throw error
    }
  }

  /**
   * 上传专辑封面
   * @param {string} albumId - 专辑ID
   * @param {File} file - 封面文件
   * @returns {Promise} - 返回包含封面URL的Promise对象
   */
  async uploadAlbumCover(albumId, file) {
    const formData = new FormData()
    formData.append('file', file)
    
    try {
      return this.post(`/albums/${albumId}/cover`, formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      })
    } catch (error) {
      console.error('上传专辑封面失败:', error)
      throw error
    }
  }

  /**
   * 获取专辑详情
   * @param {number} albumId - 专辑ID
   * @returns {Promise} - 返回专辑详情
   */
  async getAlbumDetail(albumId) {
    try {
      const response = await this.get(`/albums/${albumId}`)
      if (response.code === 200 && response.data) {
        return response.data
      } else {
        throw new Error('获取专辑详情失败')
      }
    } catch (error) {
      console.error('获取专辑详情失败:', error)
      // 出错时返回null，让调用方处理
      return null
    }
  }
}

// 导出单例实例
const apiService = new ApiService()
export default apiService